﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Reflection;

namespace DB
{
    public abstract class DBHelper
    {
        #region 需要实例化
        public abstract DbParameter NewParameter();

        public virtual DbCommand NewDbCommand()
        {
            throw new ArgumentNullException("DbCommand", "请先重写NewDbCommand()方法");
        }

        public abstract DbConnection NewConnection();
        private static DbConnection NewDbConnection(string connStr)
        {
            DbConnection dbConn = DBFactory.GetDBHelper().NewConnection();
            dbConn.ConnectionString = connStr;
            return dbConn;
        }

        public virtual DbDataAdapter NewDbDataAdapter()
        {
            throw new ArgumentNullException("DbDataAdapter", "请先重写NewDbDataAdapter()方法");
        }
        #endregion

        protected static readonly string connString = System.Configuration.ConfigurationManager.ConnectionStrings["DBConnStr"].ConnectionString;

        // Hashtable to store cached parameters
        protected static System.Collections.Hashtable parmCache = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
        #region 执行前预处理PrepareCommand() 将参数数组添加到缓存CacheParameters() 检索缓存参数GetCachedParameters()
        /// <summary>
        /// 创建数据库操作参数
        /// </summary>
        /// <param name="parameterName"></param>
        /// <param name="value"></param>
        /// <param name="direction"></param>
        /// <param name="dbType"></param>
        /// <returns></returns>
        public static DbParameter CreateParameter(string parameterName, object value, ParameterDirection direction = ParameterDirection.Input, DbType dbType = DbType.Object)
        {
            if (string.IsNullOrEmpty(parameterName))
            {
                throw new System.ArgumentNullException("传入的参数名称为空");
            }
            DbParameter parm = DBFactory.GetDBHelper().NewParameter();
            //if (parameterName.Substring(0, 1) != "@")
            //{
            //    parameterName = "@" + parameterName;
            //}
            parm.ParameterName = parameterName;
            parm.Value = value ?? DBNull.Value;
            parm.Direction = direction;
            if (dbType != DbType.Object)
                parm.DbType = dbType;
            return parm;
        }
        /// <summary>
        /// 为执行命令准备参数
        /// </summary>
        /// <param name="cmd">SqlCommand 命令</param>
        /// <param name="conn">已经存在的数据库连接</param>
        /// <param name="trans">数据库事物处理</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
        /// <param name="cmdParms">返回带参数的命令</param>
        protected static void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, CommandType cmdType, string cmdText, params DbParameter[] cmdParms)
        {
            //判断数据库连接状态
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;
            //判断是否需要事物处理
            if (trans != null)
                cmd.Transaction = trans;
            if (cmdParms != null)
            {
                foreach (DbParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
        protected static void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, CommandType cmdType, string cmdText, IList<DbParameter> cmdParms)
        {
            //判断数据库连接状态
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;
            //判断是否需要事物处理
            if (trans != null)
                cmd.Transaction = trans;
            if (cmdParms != null)
            {
                foreach (DbParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }

        /// <summary>
        /// 将参数数组添加到缓存
        /// </summary>
        /// <param name="cacheKey">参数缓存索引</param>
        /// <param name="cmdParms">将缓存的数组</param>
        public virtual void CacheParameters(string cacheKey, params DbParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        /// <summary>
        /// 检索缓存参数
        /// </summary>
        /// <param name="cacheKey">用来查找参数的索引</param>
        /// <returns>SqlParamters缓存数组</returns>
        public virtual DbParameter[] GetCachedParameters(string cacheKey)
        {
            DbParameter[] cachedParms = (DbParameter[])parmCache[cacheKey];
            if (cachedParms == null)
                return null;
            DbParameter[] clonedParms = new DbParameter[cachedParms.Length];
            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (DbParameter)((ICloneable)cachedParms[i]).Clone();
            return clonedParms;
        }

        #endregion

        #region 数据库铺助方法
        #region 判断存在
        /// <summary>
        /// 检查是否存在
        /// </summary>
        /// <param name="tableName">查询数据表名称</param>
        /// <param name="where">查询条件,前面接AND </param>
        /// <param name="cmdParms">参数</param>
        /// <returns>bool结果</returns>
        public virtual bool Exists(string tableName, string where, params DbParameter[] cmdParms)
        {
            if (string.IsNullOrWhiteSpace(where) == false)
            {
                if (where.Trim().Substring(0, 3).ToLower() != "and")
                    where = " AND " + where;
            }
            string strSql = "SELECT COUNT(1) FROM [" + tableName + "] WHERE 1=1 " + where;
            return ExecuteScalar<int>(CommandType.Text, strSql, cmdParms) > 0;
        }
        /// <summary>
        /// 检查是否存在
        /// </summary>
        /// <param name="strSql">Sql语句</param>
        /// <param name="cmdParms">参数</param>
        /// <returns>bool结果</returns>
        public virtual bool Exists(string strSql, params DbParameter[] cmdParms)
        {
            return ExecuteScalar<int>(CommandType.Text, strSql, cmdParms) > 0;
        }
        /// <summary>
        /// 检查是否存在
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public virtual bool Exists(string strSql)
        {
            return Exists(strSql, (DbParameter[])null);
        }
        /// <summary>
        /// 判断是否存在某表的某个字段
        /// </summary>
        /// <param name="tableName">表名称</param>
        /// <param name="columnName">列名称</param>
        /// <returns>是否存在</returns>
        public virtual bool ExistsColumn(string tableName, string columnName)
        {
            DbParameter[] ps = new DbParameter[]{
            DBHelper.CreateParameter("@tableName",tableName),
            DBHelper.CreateParameter("@columnName",columnName)
            };
            string strSql = "SELECT COUNT(1) FROM SYSCOLUMNS WHERE [id]=OBJECT_ID(@tableName) AND [name]=@columnName";
            return Exists(strSql, ps);
        }
        /// <summary>
        /// 检查表是否存在
        /// </summary>
        /// <param name="TableName">表名</param>
        /// <returns></returns>
        public virtual bool ExistsTab(string tableName)
        {
            DbParameter[] ps = new DbParameter[]{
            DBHelper.CreateParameter("@tableName",tableName)
            };
            string strSql = "SELECT COUNT(1) FROM SYSOBJECTS WHERE id = OBJECT_ID(@tableName) AND OBJECTPROPERTY(id, N'IsUserTable') = 1";
            //string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
            return Exists(strSql, ps);
        }
        #endregion

        #region 返回实体
        /// <summary>
        /// 返回实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connectionString"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public virtual T GetModel<T>(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters) where T : new()
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connectionString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    return DataReaderToModel<T>(rdr);
                }
            }
            //DataTable dt = GetTable(connectionString, cmdType, cmdText, commandParameters)[0];
            //return DataTableToModel<T>(dt);
        }
        public virtual T GetModel<T>(CommandType cmdType, string cmdText, params DbParameter[] commandParameters) where T : new()
        {
            return GetModel<T>(connString, cmdType, cmdText, commandParameters);
        }
        public virtual T GetModelSP<T>(string cmdText, params DbParameter[] commandParameters) where T : new()
        {
            return GetModel<T>(connString, CommandType.StoredProcedure, cmdText, commandParameters);

        }
        public virtual T GetModelText<T>(string cmdText, params DbParameter[] commandParameters) where T : new()
        {
            return GetModel<T>(connString, CommandType.Text, cmdText, commandParameters);
        }
        /// <summary>
        /// DbDataReader转Model
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="reader"></param>
        /// <returns></returns>
        public static T DataReaderToModel<T>(System.Data.Common.DbDataReader reader) where T : new()
        {
            if (reader.Read())
            {
                T m = new T();
                object val = null;

                PropertyInfo[] pros = typeof(T).GetProperties(BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                foreach (PropertyInfo pro in pros)
                {
                    var value = reader[pro.Name];
                    if (value != null && !(value is DBNull))
                    {
                        val = value;
                        pro.SetValue(m, val, null);
                    }
                }
                return m;
            }
            return default(T);
        }
        #endregion


        /// <summary>
        /// 获取最大ID(已自动+1)(检查字符串)
        /// </summary>
        /// <param name="FieldName"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public virtual T GetMaxID<T>(string fieldName, string tableName)
        {
            string strSql = "SELECT MAX([" + fieldName + "])+1 FROM [" + tableName + "]";
            return ExecuteScalar<T>(CommandType.Text, strSql, null);
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。(默认只要全部能执行就提交,不管执行结果)
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>		
        public virtual int ExecuteSqlTran(IList<string> SQLStringList)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connString))
                {
                    conn.Open();
                    cmd.Connection = conn;
                    DbTransaction trans = conn.BeginTransaction();
                    cmd.Transaction = trans;
                    try
                    {
                        int count = 0;
                        for (int n = 0; n < SQLStringList.Count; n++)
                        {
                            string strsql = SQLStringList[n];
                            if (strsql.Trim().Length > 1)
                            {
                                cmd.CommandText = strsql;
                                count += cmd.ExecuteNonQuery();
                            }
                        }
                        trans.Commit();
                        return count;
                    }
                    finally
                    {
                        trans.Rollback();
                    }
                }
            }
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务
        /// </summary>
        /// <param name="cmdList"></param>
        /// <returns></returns>
        public virtual int ExecuteSqlTran(IList<CommandInfo> cmdList)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connString))
                {
                    conn.Open();
                    using (DbTransaction trans = conn.BeginTransaction())
                    {
                        try
                        {
                            int count = 0;
                            foreach (CommandInfo obj in cmdList)
                            {
                                string cmdText = obj.CommandText;
                                IList<DbParameter> cmdParms = obj.Parameters;
                                PrepareCommand(cmd, conn, trans, CommandType.Text, cmdText, cmdParms);
                                int val = cmd.ExecuteNonQuery();
                                if (obj.EffentNextType == EffectNextType.ExcuteEffectRows && val == 0)
                                {
                                    trans.Rollback();
                                    return 0;
                                }
                                count += val;
                                cmd.Parameters.Clear();//能不能放外面
                            }
                            trans.Commit();
                            return count;
                        }
                        finally
                        {
                            trans.Rollback();
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public virtual int ExecuteSqlInsertImg(string strSQL, string ParameterName, byte[] fs)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connString))
                {
                    DbParameter cmdParms = DBHelper.CreateParameter(ParameterName, fs);
                    PrepareCommand(cmd, conn, null, CommandType.Text, strSQL, cmdParms);
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
            }
        }
        #endregion

        #region ExecteNonQuery方法,执行一个不需要返回值的SqlCommand命令(返回受影响行数)。
        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个不需要返回值的SqlCommand命令。
        /// 使用参数数组形式提供参数列表 
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public virtual int ExecteNonQuery(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connString))
                {
                    //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    int val = cmd.ExecuteNonQuery();
                    return val;
                }
            }
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个不需要返回值的SqlCommand命令。
        /// 使用参数数组形式提供参数列表 
        /// </summary>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public virtual int ExecteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            return ExecteNonQuery(connString, cmdType, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个不需要返回值的SqlCommand命令(存储过程专用)。
        /// </summary>
        /// <param name="cmdText">存储过程的名字</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public virtual int ExecteNonQuerySP(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecteNonQuery(CommandType.StoredProcedure, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个不需要返回值的SqlCommand命令(Sql语句专用)。
        /// </summary>
        /// <param name="cmdText">T_Sql语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
        public virtual int ExecteNonQueryText(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecteNonQuery(CommandType.Text, cmdText, commandParameters);
        }
        #endregion

        #region 获取结果集
        #region GetTable方法,执行一条返回结果集的SqlCommand。

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一条返回结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connecttionString">一个现有的数据库连接</param>
        /// <param name="cmdTye">SqlCommand命令类型</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
        public virtual DataTableCollection GetTable(string connecttionString, CommandType cmdTye, string cmdText, params DbParameter[] commandParameters)
        {
            DataSet ds = new DataSet();
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connString))
                {
                    PrepareCommand(cmd, conn, null, cmdTye, cmdText, commandParameters);
                    DbDataAdapter adapter = NewDbDataAdapter();
                    adapter.SelectCommand = cmd;
                    adapter.Fill(ds);
                }
            }
            DataTableCollection table = ds.Tables;
            return table;
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一条返回结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdTye">SqlCommand命令类型</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
        public virtual DataTableCollection GetTable(CommandType cmdTye, string cmdText, params DbParameter[] commandParameters)
        {
            return GetTable(connString, cmdTye, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一条返回结果集的SqlCommand。
        /// 存储过程专用
        /// </summary>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
        public virtual DataTableCollection GetTableSP(string cmdText, params DbParameter[] commandParameters)
        {
            return GetTable(connString, CommandType.StoredProcedure, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一条返回结果集的SqlCommand。
        /// Sql语句专用
        /// </summary>
        /// <param name="cmdText"> T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
        public virtual DataTableCollection GetTableText(string cmdText, params DbParameter[] commandParameters)
        {
            return GetTable(CommandType.Text, cmdText, commandParameters);
        }
        #endregion

        #region ExecuteReader方法
        /// <summary>
        /// 通过一个可访问的数据库连接执行一条T-SQL并返回SqlDataReader对象
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>一个包含结果集的SqlDataReader</returns>
        public virtual DbDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            //using (SqlCommand cmd = new SqlCommand())
            {
                DbCommand cmd = NewDbCommand();
                DbConnection conn = NewDbConnection(connectionString);
                //using (SqlConnection conn = new SqlConnection(connectionString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    return rdr;
                }
            }
        }
        /// <summary>
        /// 通过一个可访问的数据库连接执行一条T-SQL并返回SqlDataReader对象
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>一个包含结果集的SqlDataReader</returns>
        public virtual DbDataReader ExecuteReader(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteReader(connString, cmdType, cmdText, commandParameters);
        }
        /// <summary>
        /// 通过一个可访问的数据库连接执行一条T-SQL并返回SqlDataReader对象
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>一个包含结果集的SqlDataReader</returns>
        public virtual DbDataReader ExecuteReaderSP(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteReader(connString, CommandType.StoredProcedure, cmdText, commandParameters);

        }
        /// <summary>
        /// 通过一个可访问的数据库连接执行一条T-SQL并返回SqlDataReader对象
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>一个包含结果集的SqlDataReader</returns>
        public virtual DbDataReader ExecuteReaderText(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteReader(connString, CommandType.Text, cmdText, commandParameters);
        }
        #endregion

        #region ExecuteDataSet方法
        /// <summary>
        /// 通过一个可访问的数据库连接执行一个返回DataSet结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>return a dataset</returns>
        public virtual DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connectionString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    DbDataAdapter da = NewDbDataAdapter();
                    DataSet ds = new DataSet();
                    da.SelectCommand = cmd;
                    da.Fill(ds);
                    return ds;
                }
            }
        }

        /// <summary>
        /// 通过一个可访问的数据库连接执行一个返回DataSet结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>return a dataset</returns>
        public virtual DataSet ExecuteDataSet(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteDataSet(connString, cmdType, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个可访问的数据库连接执行一个返回DataSet结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdText">存储过程的名字</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>return a dataset</returns>
        public virtual DataSet ExecuteDataSetSP(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteDataSet(connString, CommandType.StoredProcedure, cmdText, commandParameters);
        }

        /// <summary>
        /// 通过一个可访问的数据库连接执行一个返回DataSet结果集的SqlCommand。
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdText">T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>return a dataset</returns>
        public virtual DataSet ExecuteDataSetText(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteDataSet(connString, CommandType.Text, cmdText, commandParameters);
        }
        #endregion
        #endregion

        #region ExecuteScalar方法,执行一个返回查询结果集中第一列第一行的数据的SqlCommand命令

        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个返回查询结果集中第一列第一行的数据的SqlCommand命令
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar<object>(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的数据库连接字符串</param>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
        public virtual T ExecuteScalar<T>(string connectionString, CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            using (DbCommand cmd = NewDbCommand())
            {
                using (DbConnection conn = NewDbConnection(connectionString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    object val = cmd.ExecuteScalar();
                    return (T)val;
                }
            }
        }
        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个返回查询结果集中第一列第一行的数据的SqlCommand命令
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
        /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个对象</returns>
        public virtual T ExecuteScalar<T>(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteScalar<T>(connString, cmdType, cmdText, commandParameters);
        }
        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个返回查询结果集中第一列第一行的数据的SqlCommand命令(存储过程专用)
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdText">存储过程的名字</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个对象</returns>
        public virtual T ExecuteScalarSP<T>(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteScalar<T>(CommandType.StoredProcedure, cmdText, commandParameters);
        }
        /// <summary>
        /// 通过一个有效可访问的数据库连接执行一个返回查询结果集中第一列第一行的数据的SqlCommand命令(T-SQL语句专用)
        /// 使用参数数组提供参数
        /// </summary>
        /// <param name="cmdText"> T-SQL 语句</param>
        /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
        /// <returns>返回一个对象</returns>
        public virtual T ExecuteScalarText<T>(string cmdText, params DbParameter[] commandParameters)
        {
            return ExecuteScalar<T>(CommandType.Text, cmdText, commandParameters);
        }
        #endregion
    }
}
